home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / misc / amag / AM9410_2.lha / Haufenweise / Programme / AllocSupport.c < prev    next >
C/C++ Source or Header  |  1994-07-15  |  3KB  |  108 lines
  1. /*
  2.  *  Support-Routinen für Allocate/Deallocate
  3.  *
  4.  *  Version: $VER: AllocSupport.c 1.0 © D. Göhler (11.07.94)
  5.  */
  6.  
  7. #include "AllocSupport.h"
  8.  
  9. /*
  10.  * AllocMemHeader alloziert einen neuen Block Speicher von
  11.  *                der globalen Speicherliste des Betriebs-
  12.  *                systems. Vom neuen Block können dann mit
  13.  *                AllocateVec() und DeallocateVec() Blöcke
  14.  *                alloziert und wieder zurückgegeben werden.
  15.  */
  16.  
  17. struct MemHeader *AllocMemHeader(ULONG Size, ULONG Flags)
  18. {
  19.    APTR             block;
  20.    struct MemHeader *mh      = 0L;
  21.    struct MemChunk  *mc;
  22.  
  23.    /* Speicher für alles besorgen */
  24.    if (block = AllocMem(Size+sizeof(*mh),Flags))
  25.    {
  26.       /* MemHeader in den Speicherblock legen */
  27.       mh = (struct MemHeader *)block;
  28.  
  29.       /* block zeigt hiernach auf den eigentlichen Anfang */
  30.       /* des freien Speicherbereichs mit der Größe Size */
  31.       block = (UBYTE *)block + sizeof(*mh);
  32.  
  33.       /* mc beschreibt das einzige freie Stück im Block */
  34.       mc = (struct MemChunk *) block;
  35.  
  36.       /* jetzt wird die Speicher-Struktur initialisiert */
  37.       mh->mh_Node.ln_Type = NT_MEMORY;
  38.       mh->mh_Node.ln_Name = 0;
  39.       mh->mh_Node.ln_Succ = NULL;
  40.       mh->mh_Node.ln_Pred = NULL;
  41.       mh->mh_First        = (struct MemChunk *)block;
  42.       mh->mh_Lower        = block;
  43.       mh->mh_Upper        = (UBYTE *)block + Size;
  44.       mh->mh_Free         = Size; // - sizeof(*mc);
  45.  
  46.       /* Der Bereich enthält zu Beginn nur 1 Stück, und
  47.          das ist genau Size Byte groß */
  48.       mc->mc_Next         = NULL;
  49.       mc->mc_Bytes        = mh->mh_Free;
  50.    }
  51.  
  52.    return mh;
  53. }
  54.  
  55. /*
  56.  * FreeMemHeader gibt den Speicher wieder frei, der mit
  57.  *               AllocMemheader alloziert wurde.
  58.  */
  59.  
  60. void FreeMemHeader(struct MemHeader *mh)
  61. {
  62.    FreeMem(mh,((UBYTE *)mh->mh_Upper - (UBYTE *)mh->mh_Lower)
  63.               + sizeof(*mh));
  64. }
  65.  
  66. /*
  67.  * AllocateVec arbeitet wie Allocate, mit dem Unterschied,
  68.  *             daß es selbst speichert, wir groß der Block
  69.  *             war. Damit muß man beim Freigeben des Blocks
  70.  *             die Länge nicht angeben.
  71.  *
  72.  * WICHTIG:    Zum Freigeben immer DeallocateVec() benutzen,
  73.  *             nie Deallocate(), da sonst Speicher verloren
  74.  *             geht.
  75.  */
  76.  
  77. void *AllocateVec(struct MemHeader *mh, ULONG len)
  78. {
  79.    APTR mem = 0L;
  80.    ULONG memlen = len + sizeof(ULONG);
  81.  
  82.    if ((len + 4) <= mh->mh_Free)
  83.    {  if (mem = Allocate(mh,memlen))
  84.       {  *(ULONG *)mem = memlen;
  85.          mem = (ULONG *)mem + 1;
  86.       }
  87.    }
  88.  
  89.    return mem;
  90. }
  91.  
  92. /*
  93.  * DeallocateVec ist das Gegenstück zu AllocateVec(). Es
  94.  *               liest die Länge aus der Langwort-Adresse
  95.  *               vor dem freizugebenden Speicherblock und
  96.  *               gibt den Block frei.
  97.  *
  98.  * WICHTIG:      Bitte diese Funktion nur mit AllocateVec()
  99.  *               benutzen, nie mit Allocate()!
  100.  */
  101.  
  102. void DeallocateVec(struct MemHeader *mh, APTR mem)
  103. {
  104.    mem = ((ULONG *)mem - 1);
  105.  
  106.    Deallocate(mh, mem, *(ULONG *)mem);
  107. }
  108.